﻿namespace NetFx.AST
{
  using System;
  using System.Text;
  using System.Collections;
  using System.Collections.Generic;

  using NetFx.SMIL.Definitions;
  using NetFx.SMIL.References;


  /// <summary>
  /// 高层语法设计：
  /// 
  /// 设计分为两个部分，一个部分是抽象高级语言；另一个部分是无语法高级语言（自然语言）。
  /// 
  /// 抽象高级语言提供已知高级语言的多数性能，以及向无语法高级语言过渡
  /// 的概念。
  /// 
  /// 抽象高级语言提供在线连接的能力。所谓在线连接，是指使用现有的C#语法结构，来
  /// 表示抽象高级语言的语法结构，就想抽象高级语言是C#语言的一个部分。
  /// 
  /// 无语法语言，即自然语言是建立在抽象高级语言之上的语言表达形式。
  /// 无语法语言不规定任何语法，但规定一些常用语义。通过将语法和
  /// 对应的语义进行人为的连接，就可以将无语法语言所表达的内容转化
  /// 为正确的抽象高级语言的形式。
  /// 无语法语言的识别主要是关于二元关系的识别和语言系统层次结构的识别。
  /// 
  /// 虽然在无语法语言中并不显式的指出类，从属，字段，方法，派生等
  /// 概念，但通过对语义树上下文的识别，同样可以抽取被描述对象的
  /// 相关特性。
  /// 
  /// 无语法语言遵循如下基本原则：
  /// 
  ///     已知优先：  首先在已知范围内发现描述所表达的含义，包括描述是否符合已有的语法结构（语法识别），
  ///                 描述是否包括已有的事物类型（归类）等。
  /// 
  ///     未知补充：  所有在已知范围内未发现的描述所表达的含义，应对现有知识体系进行补充。这包括对类型
  ///                 的补充（类的定义），对类型的细化描述（字段的定义），对类型的讨论补充（方法的定义），
  ///                 和对类型的相关补充（描述符以及内部类等）。
  /// 
  ///     二元结合：  使用二元关系作为最基本的关联依据。
  ///     
  /// 
  /// 
  /// 
  /// 
  /// 
  /// </summary>


  public abstract class AbstractDiscriptor:IDisposable  
  {
    public void Dispose()
    {
    }
  }

  public class Expression:AbstractDiscriptor
  {

    ///可以重载的运算符
    ///+, -, !, ~, ++, --, (true, false)               可以重载这些一元运算符。 
    ///+, -, *, /, %, &, |, ^, <<, >>                  可以重载这些二进制运算符。 
    ///==, !=, <, >, <=, >=                            可以重载这些比较运算符（但请参见下面的说明）。 
    ///不能重载的运算符
    ///&&, ||                                          不能重载条件逻辑运算符，但可使用 & 和 | 对其进行计算，可以重载 & 和 |；请参见 7.11.2 用户定义的条件逻辑运算符。 
    ///[]                                              不能重载数组索引运算符，但可定义索引器。 
    ///()                                              不能重载转换运算符，但可定义新的转换运算符（请参见 explicit 和 implicit）。 
    ///+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=        不能重载赋值运算符，但例外的是可使用 +（该运算符可被重载）计算 +=。 
    ///代替方案
    ///&&         .and()
    ///||         .or()
    ///[]         (this[])
    ///()         .to()
    ///>>         .right_shift()
    ///<<         .left_shift()
    /// 
    ///=, ., ?:, ->, new, is,as,sizeof, typeof         不能重载这些运算符。 
    /// 
    /// =         .is_assigned_to()
    /// .         ._()
    /// ?:        .is_true_then().else()
    /// ->        ._()
    /// new       .of()
    /// is        .is()
    /// as        .as()
    /// sizeof    ._size
    /// typeof    ._type
    /// +=        .add_with()
    /// -=        .sub_with()
    /// *=        .mul_with()
    /// /=        .div_with()
    /// %=        .mod_with()
    /// &=        .and_with()
    /// |=        .or_with()
    /// ^=        .xor_with()
    /// <<=       .left_shift_with()
    /// >>=       .right_shift_with()
    /// 
    ///注意   比较运算符（如果被重载）必须成对重载；也就是说，如果重载 ==，也必须重载 !=。反之亦然，对于 < 和 > 以及 <= 和 >= 同样如此。

    public static Expression operator +(Expression e)
    {
      return null;
    }
    public static Expression operator -(Expression e)
    {
      return null;
    }
    public static Expression operator ++(Expression e)
    {
      return null;
    }
    public static Expression operator --(Expression e)
    {
      return null;
    }
    public static Expression operator ~(Expression e)
    {
      return null;
    }
    public static Expression operator !(Expression e)
    {
      return null;
    }
    public static Expression operator +(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator -(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator *(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator /(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator %(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator &(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator |(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator ^(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator ==(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator !=(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator >(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator <(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator >=(Expression left, Expression right)
    {
      return null;
    }
    public static Expression operator <=(Expression left, Expression right)
    {
      return null;
    }

    public override int GetHashCode()
    {
      return base.GetHashCode();
    }
    public override bool Equals(object obj)
    {
      return base.Equals(obj);
    }
  }
  /// <summary>
  /// 实体。
  /// </summary>
  /// <remarks>
  /// 实体即对象的引用（或者就是对象），
  /// 在不同的上下文中，实体存在不同
  /// 的形式。例如类的实体成员即是字段，
  /// 方法（动词语义）的实体则是局部
  /// 变量。
  /// </remarks>
  public class Entity:Expression
  {
    public static Entity of(object src)
    {
      return null;
    }
    public virtual Entity _called(string name)
    {
      return null;
    }
    public virtual Entity _whose_type_is(string typename)
    {
      return this;
    }
    public virtual Entity _is_assigned_to(Expression e)
    {
      return this;
    }

    public virtual Entity this[string name]
    {
      get
      {
        return null;
      }
    }
  }

  public class Statement:AbstractDiscriptor
  {

  }
  /// <summary>
  /// 动词语义。
  /// </summary>
  /// <remarks>
  /// 我们将方法等价为可以实现的动词，
  /// 而方法的定义即可视为语义。
  /// </remarks>
  public class Semantics : AbstractDiscriptor
  {
    public static Semantics called(string name)
    {
      return null;
    }

    public virtual Entity _entity(string name)
    {
      return null;
    }


  }

  /// <summary>
  /// 存在的事物。
  /// </summary>
  /// <remarks>
  /// 存在的事物，相当于Object基类。
  /// 在这里，他代表一个类（类型）。
  /// </remarks>
  public class Objective:AbstractDiscriptor
  {
    public static Objective called(string name)
    {
      return null;
    }
    public Objective()
    {

    }

    public virtual Entity this[string name]
    {
      get
      {
        return null;
      }
    }
  }

  ///// <summary>
  ///// 可见性.
  ///// </summary>
  ///// <remarks>
  ///// 实体相当于局部变量，参数，或者字段。
  ///// 实体可见性，包括外部可见部分和内部
  ///// 可见部分。分别对应于(public)和(protected)。
  ///// 不支持private，因为实体的存在无法区分到
  ///// 这个层次。
  ///// </remarks>
  //public enum Visibility
  //{
  //  Interior = 0,     //内部，相当于Private
  //  Exterior = 1,     //外部，相当于Public
  //  Family   = 2,     //家族，相当于Protected
  //  Collectivity = 4, //集体，相当于Internal
  //}
  public class Tester
  {
    public virtual void Test()
    {
      //使用using调用Dispose，即在Dispose中实现语义的最终定义。
      //Dispose方法并不决定对象必须是被处置并且不能再次引用的，所以我们使用的
      //只是Dispose方法能够用using包围并调用的特性。

      using (Objective car = Objective.called("car"))
      {
        Entity foreLeftWheel    = Entity.of(car)._called("foreLeftWeel")._whose_type_is("wheel");
        Entity foreRightWheel   = Entity.of(car)._called("foreRightWheel")._whose_type_is("wheel");
        Entity backLeftWheel    = Entity.of(car)._called("backLeftWheel")._whose_type_is("wheel");
        Entity backRightWheel   = Entity.of(car)._called("backRightWheel")._whose_type_is("wheel");
        
        using (Semantics hello = Semantics.called("Hello"))
        {
          Entity a = Entity.of(hello)._called("a")._whose_type_is("int"),
                 b = Entity.of(hello)._called("b")._whose_type_is("int");

          Entity c = hello._entity("c")._whose_type_is("int");

          c._is_assigned_to(a + b);

          //语句不需要显式的结束符，因为树状结构已经结束了。
          car["foreLeftWheel"]["abc"]["def"]["ghi"]._is_assigned_to(a * b);


        }
      }
    }
  }

}
